﻿#define  _CRT_SECURE_NO_WARNINGS

#include<iostream>
#include<stdlib.h>
#include<vector>
#include<list>
#include<map>
#include<set>
#include<array>
#include<assert.h>
#include<string>
#include<algorithm>
#include<queue>
using namespace std;

/////////////////////////////////////////////////
////1.
//int main()
//{
//	//列表初始化（注意：不同于初始化列表!）
//	int x1 = 1;      //一般初始化
//	int x2 = { 2 };  //{}初始化一切
//	int x3{ 3 };     //{}初始化
//
//	cout << "x1=" << x1 << endl;
//	cout << "x2=" << x2 << endl;
//	cout << "x3=" << x3 << endl;
//
//	return 0;
//}
///////////////////////////////////////////////////
////2.
//struct Point
//{
//	int _x;
//	int _y;
//};
//
//int main()
//{
//	//列表初始化（注意：不同于初始化列表!）
//	
//	//去掉赋值号初始化
//	int arr1[]{ 1,2,3,4 };   
//	int arr2[5]{ 0 };        
//	Point p{ 1,2 };
//
//	int* p1 = new int(1);
//	int* p2 = new int[3]{ 1,3,4 };
//
//	return 0;
//}
/////////////////////////////////////////////////
//3.
//class Date
//{
//public:
//	Date(int year, int month, int day)
//		:_year(year)
//		, _month(month)
//		, _day(day)
//	{
//		cout << "Date(int year, int month, int day)" << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	Date d1(2022, 1, 1); // 一般方式
//	// C++11支持的列表初始化，这里会调用构造函数初始化
//	Date d2{ 2022, 1, 2 };
//	Date d3 = { 2022, 1, 3 };
//
//	Date* p4 = new Date(2022, 9, 18);
//	Date* p5 = new Date[3]{ {2022, 9, 18},{2022,9,19},{2022,9,19} };
//	return 0;
//}
//////////////////////////////////////////////////////
////4.容器的列表初始化
//class Date
//{
//public:
//	Date(int year, int month, int day)
//		:_year(year)
//		, _month(month)
//		, _day(day)
//	{
//		cout << "Date(int year, int month, int day)" << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	//一般初始化
//	vector<int> v1 (9);
//	vector<int> v2(9,9);
//
//	// C++11支持的列表初始化(容器初始化）
//	vector<int> v3 = { 1,2,3,4,5 };
//	vector<int> v4{ 6,7,8,9,10 };
//	vector<Date> v5{ {2022, 9, 18},{2022,9,19},{2022,9,19} };
//	return 0;
//}
////////////////////////////////////////////////////////
//其他容器的列表初始化

//int main()
//{
//	list<int> lt1(3);
//	list<int> lt2(3,2);
//	list<int> lt3{ 1,2,3 };
//
//	set<int> st1;
//	set<int> st2{ 4,5,6 };
//
//	map<string, string> dict = { {"排序","sort"},{"左边","left"},{"剩余","left"} };
//	return 0;
//}
///////////////////////////////////////////////////////
//int main()
//{
//	// the type of il is an initializer_list 
//	auto il = { 10, 20, 30 };
//	cout << typeid(il).name() << endl;
//	return 0;
//}
////////////////////////////////////////////////////////
//int main()
//{
//	initializer_list<double> il = { 9.9,8.8,7.7 };
//	initializer_list<double>::iterator it = il.begin();
//	//支持迭代器遍历
//	while (it != il.end())
//	{
//		cout << *it << " ";
//		it++;
//	}
//	cout << endl;
//	//也支持范围for
//	for (auto e : il)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	return 0;
//}
/////////////////////////////////////////////////////////
////模拟实现的vector使其支持{}初始化
//namespace my
//{
//	template<class T>
//	class vector
//	{
//	public:
//		typedef T* iterator;
//		vector(initializer_list<T> l)
//		{
//			_start = new T[l.size()];
//			_finish = _start + l.size();
//			_endofstorage = _start + l.size();
//			iterator vit = _start;
//			typename initializer_list<T>::iterator lit = l.begin();
//			//迭代器遍历
//			/*while (lit != l.end())
//			{
//				*vit++ = *lit++;
//			}*/
//			//范围for遍历
//			for (auto e : l)
//			{
//				cout << e << " ";
//			}
//			cout << endl;
//		}
//		vector<T>& operator=(initializer_list<T> l) 
//		{
//			vector<T> tmp(l);
//			std::swap(_start, tmp._start);
//			std::swap(_finish, tmp._finish);
//			std::swap(_endofstorage, tmp._endofstorage);
//			return *this;
//		}
//	private:
//		iterator _start;
//		iterator _finish;
//		iterator _endofstorage;
//	};
//}
//////////////////////////////////////////////////////////
//// decltype的一些使用使用场景
//template<class T1, class T2>
//void F(T1 t1, T2 t2)
//{
//	decltype(t1 * t2) ret;
//	cout << typeid(ret).name() << endl;
//}
///////////////////////////
//int main()
//{
//	const int x = 1;
//	double y = 2.2;
//	decltype(x * y) ret; // ret的类型是double
//	decltype(&x) p;      // p的类型是int*
//	cout << typeid(ret).name() << endl;
//	cout << typeid(p).name() << endl; F(1, 'a');
//	return 0;
//}
////////////////////
//int main()
//{
//	int i = 10;
//	auto p = &i;
//	auto pf = strcpy;
//	cout << typeid(p).name() << endl;
//	cout << typeid(pf).name() << endl;
//	map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
//	//map<string, string>::iterator it = dict.begin();
//	auto it = dict.begin();
//	return 0;
//}
//////////////////////////////////////////////////
//#include<array>
//int main()
//{
//	int a1[10];
//	array<int, 10> a2;  //对比C的静态数组，访问更安全
//	a1[11];             //越界不一定能检出
//	a2[12];             //只要越界，就一定能检查出
//
//	vector<int> a3(10, 0);
//	a3[12];             //只要越界，就一定能检查出(vector)就能替代array
//	return 0;
//
//}

//int main()
//{
//	// 以下的p、b、c、*p都是左值
//	int* p = new int(0);
//	int b = 1;
//	const int c = 2;
//	// 以下几个是对上面左值的左值引用
//	int*& rp = p;
//	int& rb = b;
//	const int& rc = c;
//	int& pvalue = *p;
//	return 0;
//}

//int main()
//{
//	double x = 1.1, y = 2.2;
//	// 以下几个都是常见的右值
//	10; x + y;
//	fmin(x, y);
//	// 以下几个都是对右值的右值引用
//	int&& rr1 = 10;
//	double&& rr2 = x + y;
//	double&& rr3 = fmin(x, y);
//
//	// 这里编译会报错：error C2106: “=”: 左操作数必须为左值
//	10 = 1;
//	x + y = 1;
//	fmin(x, y) = 1;
//	return 0;
//}
//
//int main()
//{
//	double x = 1.1, y = 2.2;
//	int&& rr1 = 10;
//	const double&& rr2 = x + y;
//
//	rr1 = 20;
//    rr2 = 5.5;   // 报错
//
//	return 0;
//}

//int main()
//{
//	// 左值引用只能引用左值，不能引用右值。
//	int a = 10;
//	int& ra1 = a;      // ra为a的别名
//
//	int& ra2 = 10;   // 编译失败，因为10是右值
//	// const左值引用既可引用左值，也可引用右值。
//
//	const int& ra3 = 10;
//	const int& ra4 = a;
//	return 0;
//}
//
//int main()
//{
//	// 右值引用只能右值，不能引用左值。
//	int&& r1 = 10;
//
//	// error C2440: “初始化”: 无法从“int”转换为“int &&”
//	// message : 无法将左值绑定到右值引用
//	int a = 10;
//	int&& r2 = a;
//	// 右值引用可以引用move以后的左值
//	int&& r3 = std::move(a);
//	return 0;
//}
//
//int main()
//{
//	int&& rr1 = 10;      //右值引用
//	//int* p1 = &10;     //右值不能取地址
//	cout << rr1 << endl; 
//
//	int* p = &rr1;       //但可以给右值引用后的别名取地址
//	cout << *p << endl;
//
//	return 0;
//}

//int main()
//{
//	// 左值引用只能引用左值，不能引用右值。
//	int a = 10;
//	int& ra1 = a;	   // ra为a的别名
//	//int& ra2 = 10;   // 编译失败，因为10是右值
//	
//	// const左值引用既可引用左值，也可引用右值。
//	const int& ra3 = 10;
//	const int& ra4 = a;
//	return 0;
//}
////////////////////////////////////////////////////
////模拟实现的string类
//namespace my
//{
//	class string
//	{
//	public:
//		typedef char* iterator;
//		iterator begin()
//		{
//			return _str;
//		}
//		iterator end()
//		{
//			return _str + _size;
//		}
//		string(const char* str = "")
//			:_size(strlen(str))
//			, _capacity(_size)
//		{
//			//cout << "string(char* str)" << endl;
//			_str = new char[_capacity + 1];
//			strcpy(_str, str);
//		}
//		// s1.swap(s2)
//		void swap(string& s)
//		{
//			::swap(_str, s._str);
//			::swap(_size, s._size);
//			::swap(_capacity, s._capacity);
//		}
//		// 拷贝构造
//		string(const string& s)
//			:_str(nullptr)
//		{
//			cout << "string(const string& s) -- 深拷贝" << endl;
//			string tmp(s._str);
//			swap(tmp);
//		}
//		// 赋值重载
//		string& operator=(const string& s)
//		{
//			cout << "string& operator=(string s) -- 深拷贝" << endl;
//			string tmp(s);
//			swap(tmp);
//			return *this;
//		}
//		// 移动构造
//		string(string && s)
//			:_str(nullptr)
//			, _size(0)
//			, _capacity(0)
//		{
//			cout << "string(string&& s) -- 移动语义" << endl;
//			swap(s);
//		}
//		// 移动赋值
//		string& operator=(string && s)
//		{
//			cout << "string& operator=(string&& s) -- 移动语义" << endl;
//			swap(s);
//			return *this;
//		}
//		~string()
//		{
//			delete[] _str;
//			_str = nullptr;
//		}
//		char& operator[](size_t pos)
//		{
//			assert(pos < _size);
//			return _str[pos];
//		}
//		void reserve(size_t n)
//		{
//			if (n > _capacity)
//			{
//				char* tmp = new char[n + 1];
//				strcpy(tmp, _str);
//				delete[] _str;
//				_str = tmp;
//				_capacity = n;
//			}
//		}
//		void push_back(char ch)
//		{
//			if (_size >= _capacity)
//			{
//				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
//				reserve(newcapacity);
//			}
//			_str[_size] = ch;
//			++_size;
//			_str[_size] = '\0';
//		}
//		//string operator+=(char ch) //传值传参，效率极低，会进行深拷贝
//		string& operator+=(char ch)  //左值引用解决了深拷贝问题，返回的是对象的别名
//		{
//			push_back(ch);
//			return *this;
//		}
//		const char* c_str() const
//		{
//			return _str;
//		}
//	private:
//		char* _str;
//		size_t _size;
//		size_t _capacity; // 不包含最后做标识的\0
//	};
//}
//
//
//int main()
//{
//	my::string s1("hello world");
//	s1 += '!';
//	return 0;
//}
////传值传参，效率极低，并且会进行深拷贝，但深拷贝的代价依旧很大
//void func1(my::string s)
//{}
////引用传参，且加了const,使其支持了右值引用（但这里没有体现右值引用的用处）
//void func2(const my::string& s)  //左值引用解决
//{}
//
//int main()
//{
//	my::string s1("hello world");
//	// func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
//	func1(s1);
//	func2(s1);
//	return 0;
//}


//左值引用解决的问题：
// string operator+=(char ch) 传值返回存在深拷贝
// string& operator+=(char ch) 传左值引用没有拷贝提高了效率

////左值引用不能解决的问题：
////1.+
//my::string operator+(const my::string& s, char ch)
//{
//	my::string ret(s);
//	ret += ch;
//	return ret;
//}
////2.后置++
////3.my::string to_string(int i) 




//////////////////////////////////////////////////////////////////////////////////
////
////模拟实现的string类
//namespace my
//{
//	class string
//	{
//	public:
//		typedef char* iterator;
//		iterator begin()
//		{
//			return _str;
//		}
//		iterator end()
//		{
//			return _str + _size;
//		}
//		string(const char* str = "")
//			:_size(strlen(str))
//			, _capacity(_size)
//		{
//			//cout << "string(char* str)" << endl;
//			_str = new char[_capacity + 1];
//			strcpy(_str, str);
//		}
//		// s1.swap(s2)
//		void swap(string& s)
//		{
//			::swap(_str, s._str);
//			::swap(_size, s._size);
//			::swap(_capacity, s._capacity);
//		}
//		// 拷贝构造
//		string(const string& s)
//			:_str(nullptr)
//			, _size(0)
//			, _capacity(0)
//		{
//			cout << "string(const string& s) -- 深拷贝" << endl;
//			string tmp(s._str);
//			swap(tmp);
//		}
//		// 赋值重载
//		string& operator=(const string& s)
//		{
//			cout << "string& operator=(string s) -- 深拷贝" << endl;
//			string tmp(s);
//			swap(tmp);
//			return *this;
//		}
//		// 移动构造
//		string(string&& s)
//			:_str(nullptr)
//			, _size(0)
//			, _capacity(0)
//		{
//			cout << "string(string&& s) -- 移动语义" << endl;
//			swap(s);
//		}
//		//移动赋值
//		string& operator=(string&& s)
//		{
//			cout << "string& operator=(string&& s) -- 移动语义" << endl;
//			swap(s);
//			return *this;
//		}
//		~string()
//		{
//			delete[] _str;
//			_str = nullptr;
//		}
//		char& operator[](size_t pos)
//		{
//			assert(pos < _size);
//			return _str[pos];
//		}
//		void reserve(size_t n)
//		{
//			if (n > _capacity)
//			{
//				char* tmp = new char[n + 1];
//				strcpy(tmp, _str);
//				delete[] _str;
//				_str = tmp;
//				_capacity = n;
//			}
//		}
//		void push_back(char ch)
//		{
//			if (_size >= _capacity)
//			{
//				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
//				reserve(newcapacity);
//			}
//			_str[_size] = ch;
//			++_size;
//			_str[_size] = '\0';
//		}
//		//string operator+=(char ch)
//		string& operator+=(char ch)
//		{
//			push_back(ch);
//			return *this;
//		}
//		const char* c_str() const
//		{
//			return _str;
//		}
//	private:
//		char* _str;
//		size_t _size;
//		size_t _capacity; // 不包含最后做标识的\0
//	};
//
//	//模拟实现to_string(附用my::string)
//	//string& to_string(int value) //不能使用左值引用,右值引用更无法使用，也无法解决
//	string to_string(int value)
//	{
//		bool flag = true;
//		if (value < 0)
//		{
//			flag = false;
//			value = 0 - value;
//		}
//		my::string str;
//		while (value > 0)
//		{
//			int x = value % 10;
//			value /= 10;
//			str += ('0' + x);
//		}
//		if (flag == false)
//		{
//			str += '-';
//		}
//		std::reverse(str.begin(), str.end());
//		return str;
//	}
//}


//int main()
//{
//	// 在my::string to_string(int value)函数中可以看到，这里
//	// 只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
//	my::string ret1 = my::to_string(1234);
//	cout << ret1.c_str() << endl;
//	return 0;
//}

//int main()
//{
//	my::string ret;
//	ret = my::to_string(1234);
//	cout << ret.c_str() << endl;
//
//	return 0;
//}

//int main()
//{
//	vector<int> v1 = { 1,2,3,4,5 };
//	vector<int> v2 = { 9,8,7};
//	swap(v1, v2);
//
//	return 0;
//}
/////////////////////////////////////////////////////////
////模拟实现的string类
//namespace my
//{
//	class string
//	{
//	public:
//		typedef char* iterator;
//		iterator begin()
//		{
//			return _str;
//		}
//		iterator end()
//		{
//			return _str + _size;
//		}
//		string(const char* str = "")
//			:_size(strlen(str))
//			, _capacity(_size)
//		{
//			//cout << "string(char* str)" << endl;
//			_str = new char[_capacity + 1];
//			strcpy(_str, str);
//		}
//		// s1.swap(s2)
//		void swap(string& s)
//		{
//			::swap(_str, s._str);
//			::swap(_size, s._size);
//			::swap(_capacity, s._capacity);
//		}
//		// 拷贝构造
//		string(const string& s)
//			:_str(nullptr)
//		{
//			cout << "string(const string& s) -- 深拷贝" << endl;
//			string tmp(s._str);
//			swap(tmp);
//		}
//		// 赋值重载
//		string& operator=(const string& s)
//		{
//			cout << "string& operator=(string s) -- 深拷贝" << endl;
//			string tmp(s);
//			swap(tmp);
//			return *this;
//		}
//		// 移动构造
//		string(string&& s)
//			:_str(nullptr)
//			, _size(0)
//			, _capacity(0)
//		{
//			cout << "string(string&& s) -- 移动语义" << endl;
//			swap(s);
//		}
//		// 移动赋值
//		string& operator=(string&& s)
//		{
//			cout << "string& operator=(string&& s) -- 移动语义" << endl;
//			swap(s);
//			return *this;
//		}
//		~string()
//		{
//			delete[] _str;
//			_str = nullptr;
//		}
//		char& operator[](size_t pos)
//		{
//			assert(pos < _size);
//			return _str[pos];
//		}
//		void reserve(size_t n)
//		{
//			if (n > _capacity)
//			{
//				char* tmp = new char[n + 1];
//				strcpy(tmp, _str);
//				delete[] _str;
//				_str = tmp;
//				_capacity = n;
//			}
//		}
//		void push_back(char ch)
//		{
//			if (_size >= _capacity)
//			{
//				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
//				reserve(newcapacity);
//			}
//			_str[_size] = ch;
//			++_size;
//			_str[_size] = '\0';
//		}
//		//string operator+=(char ch)
//		string& operator+=(char ch)
//		{
//			push_back(ch);
//			return *this;
//		}
//		const char* c_str() const
//		{
//			return _str;
//		}
//	private:
//		char* _str;
//		size_t _size;
//		size_t _capacity; // 不包含最后做标识的\0
//	};
//}
////模拟实现to_string(附用my::string)
//namespace my
//{
//	my::string to_string(int value)
//	{
//		bool flag = true;
//		if (value < 0)
//		{
//			flag = false;
//			value = 0 - value;
//		}
//		my::string str;
//		while (value > 0)
//		{
//			int x = value % 10;
//			value /= 10;
//			str += ('0' + x);
//		}
//		if (flag == false)
//		{
//			str += '-';
//		}
//		std::reverse(str.begin(), str.end());
//		return str;
//	}
//}
//template<class _Ty>
//inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
//{
//	// forward _Arg as movable
//	return ((typename remove_reference<_Ty>::type&&)_Arg);
//}
//int main()
//{
//	my::string s1("hello world");
//	// 这里s1是左值，调用的是拷贝构造
//	my::string s2(s1);
//	// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
//	// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
//	// 资源被转移给了s3，s1被置空了。
//	my::string s3(std::move(s1));
//	return 0;
//}
//
//void push_back(value_type&& val);
//int main()
//{
//	list<my::string> lt;
//	my::string s1("1111");
//	// 这里调用的是拷贝构造
//	lt.push_back(s1);
//	// 下面调用都是移动构造
//	lt.push_back("2222");
//	lt.push_back(std::move(s1));
//	return 0;
//}
//运行结果：
// string(const string& s) -- 深拷贝
// string(string&& s) -- 移动语义
// string(string&& s) -- 移动语义
/////////////////////////////////////////////////////////////////////////
	
//void Fun(int& x) { cout << "左值引用" << endl; }
//void Fun(const int& x) { cout << "const 左值引用" << endl; }
//void Fun(int&& x) { cout << "右值引用" << endl; }
//void Fun(const int&& x) { cout << "const 右值引用" << endl; }
//// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
//// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
//// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
//// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
//template<typename T>
//void PerfectForward(T&& t) 
//{
//	Fun(t);
//}
//int main()
//{
//	PerfectForward(10);           // 右值
//	int a;
//	PerfectForward(a);            // 左值
//	PerfectForward(std::move(a)); // 右值
//	const int b = 8;
//	PerfectForward(b);			  // const 左值
//	PerfectForward(std::move(b)); // const 右值
//	return 0;
//}

//模拟实现的string类
namespace my
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			//cout << "string(char* str)" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		// 拷贝构造
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		// 移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移动语义" << endl;
			swap(s);
		}
		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移动语义" << endl;
			swap(s);
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}
			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}
		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity; // 不包含最后做标识的\0
	};
}
//void Fun(int& x) { cout << "左值引用" << endl; }
//void Fun(const int& x) { cout << "const 左值引用" << endl; }
//void Fun(int&& x) { cout << "右值引用" << endl; }
//void Fun(const int&& x) { cout << "const 右值引用" << endl; }
//// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
//// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
//// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
//// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
//template<typename T>
//void PerfectForward(T&& t)
//{
//	//my::string copy=t;
//	//my::string copy = move(t);
//	my::string copy2 = std::forward<T>(t);
//
//}
//int main()
//{
//	my::string s1("aaaaaa");
//	PerfectForward(s1);
//	PerfectForward(my::string("bbbbbbb"));
//	return 0;
//}


//void Fun(int& x) { cout << "左值引用" << endl; }
//void Fun(const int& x) { cout << "const 左值引用" << endl; }
//void Fun(int&& x) { cout << "右值引用" << endl; }
//void Fun(const int&& x) { cout << "const 右值引用" << endl; }
//// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
//template<typename T>
//void PerfectForward(T&& t)
//{
//	Fun(std::forward<T>(t));
//}
//int main()
//{
//	PerfectForward(10);           // 右值
//	int a;
//	PerfectForward(a);            // 左值
//	PerfectForward(std::move(a)); // 右值
//	const int b = 8;
//	PerfectForward(b);            // const 左值
//	PerfectForward(std::move(b)); // const 右值
//	return 0;
//}

//template<class T>
//struct ListNode
//{
//	ListNode* _next = nullptr;
//	ListNode* _prev = nullptr;
//	T _data;
//};
//template<class T>
//class List
//{
//	typedef ListNode<T> Node;
//public:
//	List()
//	{
//		_head = new Node;
//		_head->_next = _head;
//		_head->_prev = _head;
//	}
//	void PushBack(T&& x)
//	{
//		//Insert(_head, x);
//		Insert(_head, std::forward<T>(x));
//	}
//	void PushFront(T&& x)
//	{
//		//Insert(_head->_next, x);
//		Insert(_head->_next, std::forward<T>(x));
//	}
//	void Insert(Node* pos, T&& x)
//	{
//		Node* prev = pos->_prev;
//		Node* newnode = new Node;
//		newnode->_data = std::forward<T>(x); // 关键位置
//		// prev newnode pos
//		prev->_next = newnode;
//		newnode->_prev = prev;
//		newnode->_next = pos;
//		pos->_prev = newnode;
//	}
//	void Insert(Node* pos, const T& x)
//	{
//		Node* prev = pos->_prev;
//		Node* newnode = new Node;
//		newnode->_data = x; // 关键位置
//		// prev newnode pos
//		prev->_next = newnode;
//		newnode->_prev = prev;
//		newnode->_next = pos;
//		pos->_prev = newnode;
//	}
//private:
//	Node* _head;
//};
//int main()
//{
//	List<my::string> lt;
//	lt.PushBack("1111");
//	lt.PushFront("2222");
//	return 0;
//}

//// 涉及resize / operator[]
//class Solution
//{
//public:
//	// 核心思想：找出杨辉三角的规律，发现每一行头尾都是1，中间第[j]个数等于上一行[j-1]+
//	[j]
//	vector<vector<int>> generate(int numRows) {
//		vector<vector<int>> vv;
//		// 先开辟杨辉三角的空间
//		vv.resize(numRows);
//		for (size_t i = 1; i <= numRows; ++i)
//		{
//			vv[i - 1].resize(i, 0);
//			// 每一行的第一个和最后一个都是1
//			vv[i - 1][0] = 1;
//			vv[i - 1][i - 1] = 1;
//		}
//		for (size_t i = 0; i < vv.size(); ++i)
//		{
//			for (size_t j = 0; j < vv[i].size(); ++j)
//			{
//				if (vv[i][j] == 0)
//				{
//					vv[i][j] = vv[i - 1][j - 1] + vv[i - 1][j];
//				}
//			}
//		}
//		return vv;
//	}
//};
//class Person
//{
//public:
//	Person(const char* name = "", int age = 0)
//		:_name(name)
//		, _age(age)
//	{}
//	Person(const Person& p)
//		:_name(p._name)
//		, _age(p._age)
//	{}
//	Person(Person&& p) = default;
//private:
//	my::string _name;
//	int _age;
//};
//int main()
//{
//	Person s1;
//	Person s2 = s1;
//	Person s3 = std::move(s1);
//	return 0;
//}
//class Person
//{
//public:
//	Person(const char* name = "", int age = 0)
//		:_name(name)
//		, _age(age)
//	{}
//	Person(const Person& p) = delete;
//private:
//	my::string _name;
//	int _age;
//};
//int main()
//{
//	Person s1;
//	Person s2 = s1;
//	Person s3 = std::move(s1);
//	return 0;
//}

//// 递归终止函数
//template <class T>
//void ShowList(const T& t) 
//{
//	cout << t << endl;
//}
//// 展开函数
//template <class T, class ...Args>
//void ShowList(T value, Args... args) 
//{
//	cout << value << " ";
//	ShowList(args...);
//}
//int main()
//{
//	ShowList(1);
//	ShowList(1, 'A');
//	ShowList(1, 'A', std::string("sort"));
//	return 0;
//}
//
//template <class T>
//void PrintArg(T t) 
//{
//	cout << t << " ";
//}
////展开函数
//template <class ...Args>
//void ShowList(Args... args) 
//{
//	int arr[] = { (PrintArg(args), 0)... };
//	cout << endl;
//}
//int main()
//{
//	ShowList(1);
//	ShowList(1, 'A');
//	ShowList(1, 'A', std::string("sort"));
//	return 0;
//}

//int main()
//{
//	std::list< std::pair<int, char> > mylist;
//	// emplace_back支持可变参数，拿到构建pair对象的参数后自己去创建对象
//	// 那么在这里我们可以看到除了用法上，和push_back没什么太大的区别
//	mylist.emplace_back(10, 'a');
//	mylist.emplace_back(20, 'b');
//	mylist.emplace_back(make_pair(30, 'c'));
//	mylist.push_back(make_pair(40, 'd'));
//	mylist.push_back({ 50, 'e' });
//	for (auto e : mylist)
//		cout << e.first << ":" << e.second << endl;
//	return 0;
//}
int main()
{
	// 下面我们试一下带有拷贝构造和移动构造的bit::string，再试试呢
	// 我们会发现其实差别也不到，emplace_back是直接构造了，push_back
	// 是先构造，再移动构造，其实也还好。
	std::list< std::pair<int, my::string> > mylist;
	mylist.emplace_back(10, "sort");
	mylist.emplace_back(make_pair(20, "sort"));
	mylist.push_back(make_pair(30, "sort"));
	mylist.push_back({ 40, "sort" });
	return 0;
}
//
//// Args是一个模板参数包，args是一个函数形参参数包
//// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
//template <class T>
//void ShowList(const T& val)
//{
//	cout <<  val << "->" << typeid(val).name() << endl;
//}
//template <class T,class ...Args>
//void ShowList(const T& val,Args... args)
//{
//	//参数个数
//	cout << sizeof...(args) << endl;
//	cout << val <<"->" << typeid(val).name() << endl;
//	ShowList(args...);
//}
//int main()
//{
//	ShowList(1, 'x', 1.1);
//	//ShowList(1, 2, 3, 4, 5);
//	return 0;
//}
//// Args是一个模板参数包，args是一个函数形参参数包
//// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
//void ShowList()
//{}
//template <class T, class ...Args>
//void ShowList(const T& val, Args... args)
//{
//	//参数个数
//	cout << sizeof...(args) << endl;
//	cout << val << "->" << typeid(val).name() << endl;
//	ShowList(args...);
//}
//int main()
//{
//	ShowList(1, 'x', 1.1);
//	cout << endl;
//	ShowList(1, 2, 3, 4, 5);
//	return 0;
//}


//template <class T>
//void PrintArg(T t)
//{
//	cout << t << " ";
//}
////展开函数
//template <class ...Args>
//void ShowList(Args... args)
//{
//	int arr[] = { (PrintArg(args), 0)... };
//	cout << endl;
//}
//int main()
//{
//	ShowList(1);
//	ShowList(1, 'A');
//	ShowList(1, 'A', std::string("sort"));
//	return 0;
//}

//int main()
//{
//	string str("mytest string!");
//	
//	for (auto e : str)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	return 0;
////}
//int main()
//{
//	string str("mytest string!");
//	//范围for遍历（本质会被迭代器替换）
//	for (auto e : str)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	return 0;
//}


